1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package com.google.common.collect.testing.google;
18
19 import static com.google.common.base.Preconditions.checkArgument;
20
21 import com.google.common.collect.Multiset;
22 import com.google.common.collect.Multiset.Entry;
23 import com.google.common.collect.Multisets;
24 import com.google.common.collect.testing.AbstractCollectionTestSuiteBuilder;
25 import com.google.common.collect.testing.AbstractTester;
26 import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
27 import com.google.common.collect.testing.Helpers;
28 import com.google.common.collect.testing.OneSizeTestContainerGenerator;
29 import com.google.common.collect.testing.SampleElements;
30 import com.google.common.collect.testing.SetTestSuiteBuilder;
31 import com.google.common.collect.testing.TestSetGenerator;
32 import com.google.common.collect.testing.features.CollectionFeature;
33 import com.google.common.collect.testing.features.Feature;
34 import com.google.common.collect.testing.testers.CollectionSerializationEqualTester;
35 import com.google.common.testing.SerializableTester;
36
37 import junit.framework.TestSuite;
38
39 import java.util.ArrayList;
40 import java.util.Collection;
41 import java.util.Collections;
42 import java.util.HashSet;
43 import java.util.LinkedHashMap;
44 import java.util.LinkedHashSet;
45 import java.util.List;
46 import java.util.Map;
47 import java.util.Set;
48
49
50
51
52
53
54
55
56 public class MultisetTestSuiteBuilder<E> extends
57 AbstractCollectionTestSuiteBuilder<MultisetTestSuiteBuilder<E>, E> {
58 public static <E> MultisetTestSuiteBuilder<E> using(
59 TestMultisetGenerator<E> generator) {
60 return new MultisetTestSuiteBuilder<E>().usingGenerator(generator);
61 }
62
63 public enum NoRecurse implements Feature<Void> {
64 NO_ENTRY_SET;
65
66 @Override
67 public Set<Feature<? super Void>> getImpliedFeatures() {
68 return Collections.emptySet();
69 }
70 }
71
72 @Override protected List<Class<? extends AbstractTester>> getTesters() {
73 List<Class<? extends AbstractTester>> testers
74 = Helpers.copyToList(super.getTesters());
75 testers.add(CollectionSerializationEqualTester.class);
76 testers.add(MultisetAddTester.class);
77 testers.add(MultisetContainsTester.class);
78 testers.add(MultisetCountTester.class);
79 testers.add(MultisetElementSetTester.class);
80 testers.add(MultisetEqualsTester.class);
81 testers.add(MultisetReadsTester.class);
82 testers.add(MultisetSetCountConditionallyTester.class);
83 testers.add(MultisetSetCountUnconditionallyTester.class);
84 testers.add(MultisetRemoveTester.class);
85 testers.add(MultisetEntrySetTester.class);
86 testers.add(MultisetIteratorTester.class);
87 testers.add(MultisetSerializationTester.class);
88 return testers;
89 }
90
91 private static Set<Feature<?>> computeEntrySetFeatures(
92 Set<Feature<?>> features) {
93 Set<Feature<?>> derivedFeatures = new HashSet<Feature<?>>();
94 derivedFeatures.addAll(features);
95 derivedFeatures.remove(CollectionFeature.GENERAL_PURPOSE);
96 derivedFeatures.remove(CollectionFeature.SUPPORTS_ADD);
97 derivedFeatures.remove(CollectionFeature.ALLOWS_NULL_VALUES);
98 derivedFeatures.add(CollectionFeature.REJECTS_DUPLICATES_AT_CREATION);
99 if (!derivedFeatures.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS)) {
100 derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
101 }
102 return derivedFeatures;
103 }
104
105 static Set<Feature<?>> computeElementSetFeatures(
106 Set<Feature<?>> features) {
107 Set<Feature<?>> derivedFeatures = new HashSet<Feature<?>>();
108 derivedFeatures.addAll(features);
109 derivedFeatures.remove(CollectionFeature.GENERAL_PURPOSE);
110 derivedFeatures.remove(CollectionFeature.SUPPORTS_ADD);
111 if (!derivedFeatures.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS)) {
112 derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
113 }
114 return derivedFeatures;
115 }
116
117 private static Set<Feature<?>> computeReserializedMultisetFeatures(
118 Set<Feature<?>> features) {
119 Set<Feature<?>> derivedFeatures = new HashSet<Feature<?>>();
120 derivedFeatures.addAll(features);
121 derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
122 derivedFeatures.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS);
123 return derivedFeatures;
124 }
125
126 @Override
127 protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<
128 ?, ? extends OneSizeTestContainerGenerator<Collection<E>, E>> parentBuilder) {
129 List<TestSuite> derivedSuites = new ArrayList<TestSuite>(
130 super.createDerivedSuites(parentBuilder));
131
132 derivedSuites.add(createElementSetTestSuite(parentBuilder));
133
134 if (!parentBuilder.getFeatures().contains(NoRecurse.NO_ENTRY_SET)) {
135 derivedSuites.add(
136 SetTestSuiteBuilder.using(new EntrySetGenerator<E>(parentBuilder.getSubjectGenerator()))
137 .named(getName() + ".entrySet")
138 .withFeatures(computeEntrySetFeatures(parentBuilder.getFeatures()))
139 .suppressing(parentBuilder.getSuppressedTests())
140 .createTestSuite());
141 }
142
143 if (parentBuilder.getFeatures().contains(CollectionFeature.SERIALIZABLE)) {
144 derivedSuites.add(MultisetTestSuiteBuilder
145 .using(new ReserializedMultisetGenerator<E>(parentBuilder.getSubjectGenerator()))
146 .named(getName() + " reserialized")
147 .withFeatures(computeReserializedMultisetFeatures(parentBuilder.getFeatures()))
148 .suppressing(parentBuilder.getSuppressedTests())
149 .createTestSuite());
150 }
151 return derivedSuites;
152 }
153
154 TestSuite createElementSetTestSuite(FeatureSpecificTestSuiteBuilder<
155 ?, ? extends OneSizeTestContainerGenerator<Collection<E>, E>> parentBuilder) {
156 return SetTestSuiteBuilder
157 .using(new ElementSetGenerator<E>(parentBuilder.getSubjectGenerator()))
158 .named(getName() + ".elementSet")
159 .withFeatures(computeElementSetFeatures(parentBuilder.getFeatures()))
160 .suppressing(parentBuilder.getSuppressedTests())
161 .createTestSuite();
162 }
163
164 static class ElementSetGenerator<E> implements TestSetGenerator<E> {
165 final OneSizeTestContainerGenerator<Collection<E>, E> gen;
166
167 ElementSetGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
168 this.gen = gen;
169 }
170
171 @Override
172 public SampleElements<E> samples() {
173 return gen.samples();
174 }
175
176 @Override
177 public Set<E> create(Object... elements) {
178 Object[] duplicated = new Object[elements.length * 2];
179 for (int i = 0; i < elements.length; i++) {
180 duplicated[i] = elements[i];
181 duplicated[i + elements.length] = elements[i];
182 }
183 return ((Multiset<E>) gen.create(duplicated)).elementSet();
184 }
185
186 @Override
187 public E[] createArray(int length) {
188 return gen.createArray(length);
189 }
190
191 @Override
192 public Iterable<E> order(List<E> insertionOrder) {
193 return gen.order(new ArrayList<E>(new LinkedHashSet<E>(insertionOrder)));
194 }
195 }
196
197 static class EntrySetGenerator<E> implements TestSetGenerator<Multiset.Entry<E>> {
198 final OneSizeTestContainerGenerator<Collection<E>, E> gen;
199
200 private EntrySetGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
201 this.gen = gen;
202 }
203
204 @Override
205 public SampleElements<Multiset.Entry<E>> samples() {
206 SampleElements<E> samples = gen.samples();
207 return new SampleElements<Multiset.Entry<E>>(
208 Multisets.immutableEntry(samples.e0, 3),
209 Multisets.immutableEntry(samples.e1, 4),
210 Multisets.immutableEntry(samples.e2, 1),
211 Multisets.immutableEntry(samples.e3, 5),
212 Multisets.immutableEntry(samples.e4, 2));
213 }
214
215 @Override
216 public Set<Multiset.Entry<E>> create(Object... entries) {
217 List<Object> contents = new ArrayList<Object>();
218 Set<E> elements = new HashSet<E>();
219 for (Object o : entries) {
220 @SuppressWarnings("unchecked")
221 Multiset.Entry<E> entry = (Entry<E>) o;
222 checkArgument(elements.add(entry.getElement()),
223 "Duplicate keys not allowed in EntrySetGenerator");
224 for (int i = 0; i < entry.getCount(); i++) {
225 contents.add(entry.getElement());
226 }
227 }
228 return ((Multiset<E>) gen.create(contents.toArray())).entrySet();
229 }
230
231 @SuppressWarnings("unchecked")
232 @Override
233 public Multiset.Entry<E>[] createArray(int length) {
234 return new Multiset.Entry[length];
235 }
236
237 @Override
238 public Iterable<Entry<E>> order(List<Entry<E>> insertionOrder) {
239
240 Map<E, Entry<E>> map = new LinkedHashMap<E, Entry<E>>();
241 for (Entry<E> entry : insertionOrder) {
242 map.put(entry.getElement(), entry);
243 }
244
245 Set<E> seen = new HashSet<E>();
246 List<Entry<E>> order = new ArrayList<Entry<E>>();
247 for (E e : gen.order(new ArrayList<E>(map.keySet()))) {
248 if (seen.add(e)) {
249 order.add(map.get(e));
250 }
251 }
252 return order;
253 }
254 }
255
256 static class ReserializedMultisetGenerator<E> implements TestMultisetGenerator<E>{
257 final OneSizeTestContainerGenerator<Collection<E>, E> gen;
258
259 private ReserializedMultisetGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
260 this.gen = gen;
261 }
262
263 @Override
264 public SampleElements<E> samples() {
265 return gen.samples();
266 }
267
268 @Override
269 public Multiset<E> create(Object... elements) {
270 return (Multiset<E>) SerializableTester.reserialize(gen.create(elements));
271 }
272
273 @Override
274 public E[] createArray(int length) {
275 return gen.createArray(length);
276 }
277
278 @Override
279 public Iterable<E> order(List<E> insertionOrder) {
280 return gen.order(insertionOrder);
281 }
282 }
283 }
284